/**
 * Buffer 缓冲器
 *          Buffer是Node.js中用于处理二进制数据的全局对象、用于存储图片、视频、音频、文件等
 *          Node为了方便开发者可以完成更多功能、提供了一个类 Buffer、并且是全局的
 */

/**
 *  Buffer 创建方式
 *  1、创建方式一：Buffer.alloc()
 *      1.1 创建一个指定大小的、初始化的Buffer
 */
console.log(`
【创建方式一】：Buffer.alloc()
    `);

let bur_all1 = Buffer.alloc(10); // 创建10字节的Buffer，默认填充0
let bur_all2 = Buffer.alloc(10, 2); // 创建10字节的Buffer，填充 2
let bur_all3 = Buffer.alloc(10, ""); // 创建10字节的Buffer，填充 a
console.log(bur_all1, bur_all1.toString()); //
console.log(bur_all2, bur_all2.toString()); //
console.log(bur_all3, bur_all3.toString()); // aaaaaaaaaa

/**
 * 2、创建方式二：Buffer.allocUnsafe()
 *      2.1 创建一个指定大小的、未初始化的Buffer
 *      2.2 性能更好、但可能包含旧数据
 *      2.3 不建议使用、因为可能包含敏感数据
 */
console.log(`
【创建方式二】：Buffer.allocUnsafe() 性能更好、但可能包含旧数据
    `);

let buf_allUnsafe = Buffer.allocUnsafe(10);
const str = ["a", "b", "c", "d", "e", "f", "g", "h", "i", "j"];
for (let i = 0; i < str.length; i++) {
  // buf_allUnsafe.fill(传入项, 所在索引值, 填充长度);
  buf_allUnsafe.fill(str[i], i, str.length);
}
console.log(buf_allUnsafe);
console.log(buf_allUnsafe.toString());

/**
 * 3、创建方式三：Buffer.from()
 */
console.log(`
【创建方式三】：Buffer.from()
    `);

let buf_from = Buffer.from("hello buffer");
console.log("字符串创建：", buf_from.toString());

let buf_from1 = Buffer.from("你好 buffer", "utf-8");
console.log("创建UTF8字符串：", buf_from1.toString());

/**
 * Buffer.isBuffer(obj)
 */
console.log(` 
【Buffer静态方法】：  Buffer.isBuffer(obj) 判断是否是Buffer对象
     参数：
        obj 要判断的对象
     返回值：
        true 是Buffer对象
        false 不是Buffer对象
     示例：
        Buffer.isBuffer(buf_from)
        Buffer.isBuffer("hello")
`);
let isBuffer = Buffer.isBuffer(buf_from);
console.log("Buffer.isBuffer(obj)：", isBuffer);

/**
 * Buffer.isEncoding(encoding)
 */
console.log(`
【Buffer静态方法】： Buffer.isEncoding(encoding) 判断是否是编码
    参数：
        encoding 要判断的编码
    返回值：
        true 是编码
        false 不是编码
    示例：
        Buffer.isEncoding("utf-8")
        Buffer.isEncoding("base64")
    `);
let isEncoding = Buffer.isEncoding("utf-8");
console.log("Buffer.isEncoding(encoding)：", isEncoding);

let isEncoding1 = Buffer.isEncoding("base64");
console.log("Buffer.isEncoding(encoding)：", isEncoding1);

let isEncoding2 = Buffer.isEncoding("jdk");
console.log("Buffer.isEncoding(encoding)：", isEncoding2);

/**
 * Buffer.compare(buf1, buf2)
 */
console.log(`
【Buffer静态方法】： Buffer.compare(buf1, buf2) 比较两个Buffer是否相等
    参数：
        buf1 要比较的Buffer
        buf2 要比较的Buffer
    返回值：
        0 相等
        1 buf1大于buf2
        -1 buf1小于buf2
    示例：
        Buffer.compare(buf_from, buf_from1)
`);
let compare = Buffer.compare(Buffer.from("1"), Buffer.from("2"));
console.log("Buffer.compare(buf1, buf2)：", compare);

/**
 * Buffer.concat(list[, totalLength])
 */
console.log(`
【Buffer静态方法】： Buffer.concat(list[, totalLength]) 合并多个Buffer
    参数：
        list 要合并的Buffer数组
        totalLength 合并后的Buffer总长度
    返回值：
        合并后的Buffer
    示例：
        Buffer.concat([buf_from, buf_from1])
`);
let concat = Buffer.concat([Buffer.from("1"), Buffer.from("2")]);
console.log("Buffer.concat(list[, totalLength])：", concat);
console.log("Buffer.concat(list[, totalLength])：", concat.toString());

/**
 * Buffer.byteLength(string[, encoding])
 */
console.log(`
【Buffer静态方法】： Buffer.byteLength(string[, encoding]) 计算字符串的字节长度
    参数：
        string 要计算的字符串
        encoding 字符串的编码
    返回值：
        字符串的字节长度
    示例：
        Buffer.byteLength("hello")
`);
let byteLength = Buffer.byteLength("hello");
console.log("Buffer.byteLength(string[, encoding])：", byteLength);

let byteLength1 = Buffer.byteLength("你好", "utf-8");
console.log("Buffer.byteLength(string[, encoding])：", byteLength1);

/**
 * buf.length
 */
console.log(`
【Buffer实例方法】： buf.length 计算Buffer的字节长度
    参数：
        无
    返回值：
        Buffer的字节长度
    示例：
        buf.length
`);
console.log("buf.length：", buf_from.length);

console.log(`
【Buffer实例方法】： buf.toString([encoding[, start[, end]]]) 转换为字符串
    参数：
        encoding 编码 默认utf-8
        start 开始索引 默认0
        end 结束索引 默认buf.length
    返回值：
        字符串
    示例：
        buf.toString()
`);
console.log("buf.toString()：", buf_from.toString());

console.log(`
【Buffer实例方法】： buf.write(string[, offset[, length[, encoding]]]) 在Buffer的指定位置写入字符串
    参数：
        string 要写入的字符串 
        offset 开始写入的索引 默认0
        length 写入的字节长度 默认string.length
        encoding 字符串的编码 默认utf-8
    返回值：
        写入的字节长度
    示例：
        buf.write("hello", 0, 5, "utf-8")
`);
const buf_write = Buffer.alloc(20);
buf_write.write("hello nestjs", 0, 12, "utf-8");
console.log("buf.write()：", buf_write.toString(), buf_write);

console.log(`
【Buffer实例方法】： buf.slice([start[, end]]) 复制Buffer的指定位置
    参数：
        start 开始索引 默认0
        end 结束索引 默认buf.length
    返回值：
        复制后的Buffer
    示例：
        buf.slice(0, 5)
`);
const buf_slice = buf_write.slice(0, 5);
console.log("buf.slice()：", buf_slice.toString(), buf_slice);




console.log(`
【Buffer实例方法】： buf.copy(target[, targetStart[, sourceStart[, sourceEnd]]]) 复制Buffer的指定位置到目标Buffer
    参数：
        target 目标Buffer
        targetStart 目标Buffer开始写入的索引 默认0
        sourceStart 源Buffer开始复制的索引 默认0
        sourceEnd 源Buffer结束复制的索引 默认buf.length
    返回值：
        无
    示例：
        buf.copy(target, 0, 0, 5)
`);
const buf_copy = Buffer.alloc(10);
buf_write.copy(buf_copy, 0, 0, buf_write.length);
console.log("buf.copy()：", buf_copy.toString(), buf_copy);




console.log(`
【Buffer实例方法】： buf.fill(value[, offset[, end]]) 填充Buffer
    参数：
        value 要填充的值
        offset 开始填充的索引 默认0
        end 结束填充的索引 默认buf.length
    返回值：
        无
    示例：
        buf.fill("a")
`);
const buf_fill = Buffer.alloc(10);
buf_fill.fill("a");
console.log("buf.fill()：", buf_fill.toString(), buf_fill);
buf_fill.fill("b", 5, 10);
console.log("buf.fill()：", buf_fill.toString(), buf_fill);




console.log(`
【Buffer实例方法】： buf.equals(otherBuffer) 判断Buffer是否相等
    参数：
        otherBuffer 要判断的Buffer
    返回值：
        true 相等
        false 不相等
    示例：
        buf.equals(otherBuffer)
`);
const buf_equals = Buffer.alloc(10);
buf_equals.fill("a");
console.log("buf.equals()：", buf_equals.equals(buf_fill));
console.log("buf.equals()：", buf_equals.equals(Buffer.from("a")));




console.log(`
【Buffer实例方法】：buf.indexOf(value[, byteOffset[, encoding]]) 查找Buffer是否包含指定值
    参数：
        value 要查找的值
        byteOffset 开始查找的索引 默认0
        encoding 字符串的编码 默认utf-8
    返回值：
        找到的索引
        -1 未找到
    示例：
        buf.indexOf("a")
`);
console.log("buf.indexOf()：", buf_equals.indexOf("a"));
console.log("buf.indexOf()：", buf_equals.indexOf("b"));
console.log("buf.indexOf()：", buf_equals.indexOf("a", 5));




console.log(`
【Buffer实例方法】：buf.lastIndexOf(value[, byteOffset[, encoding]]) 查找Buffer是否包含指定值
    参数：
        value 要查找的值
        byteOffset 开始查找的索引 默认buf.length
        encoding 字符串的编码 默认utf-8
    返回值：
        找到的索引
        -1 未找到
    示例：
        buf.lastIndexOf("a")
`);
console.log("buf.lastIndexOf()：", buf_equals.lastIndexOf("a"));
console.log("buf.lastIndexOf()：", buf_equals.lastIndexOf("b"));
console.log("buf.lastIndexOf()：", buf_equals.lastIndexOf("a", 5));




console.log(`
【Buffer实例方法】：buf.includes(value[, byteOffset[, encoding]]) 判断Buffer是否包含指定值
    参数：
        value 要查找的值
        byteOffset 开始查找的索引 默认0
        encoding 字符串的编码 默认utf-8
    返回值：
        true 包含
        false 不包含
    示例：
        buf.includes("a")
`);
console.log("buf.includes()：", buf_equals.includes("a"));
console.log("buf.includes()：", buf_equals.includes("b"));
console.log("buf.includes()：", buf_equals.includes("a", 5));




console.log(`
【Buffer实例方法】：buf.keys() 遍历Buffer的每个字节
    参数：
        无
    返回值：
        无
    示例：
        buf.keys()
`);
console.log("buf.keys()：", buf_equals.keys());
for (const key of buf_equals.keys()) {
    console.log(key);
}




console.log(`
【Buffer实例方法】：buf.values() 遍历Buffer的每个字节
    参数：
        无
    返回值：
        无
    示例：
        buf.values()
`);
console.log("buf.values()：", buf_equals.values());
for (const value of buf_equals.values()) {
    console.log(value);
}




console.log(`
【Buffer实例方法】：buf.entries() 遍历Buffer的每个字节
    参数：
        无
    返回值：
        返回一个迭代器，遍历Buffer的所有字节值
    示例：
        buf.entries()
`);
console.log("buf.entries()：", buf_equals.entries());
for (const entry of buf_equals.entries()) {
    console.log(entry);
}


console.log(`
Buffer【方法总结】
    1. buf.slice([start[, end]]) 复制Buffer的指定位置
    2. buf.copy(target[, targetStart[, sourceStart[, sourceEnd]]]) 复制Buffer的指定位置到目标Buffer
    3. buf.fill(value[, offset[, end]]) 填充Buffer
    4. buf.equals(otherBuffer) 判断Buffer是否相等
    5. buf.indexOf(value[, byteOffset[, encoding]]) 查找Buffer是否包含指定值
    6. buf.lastIndexOf(value[, byteOffset[, encoding]]) 查找Buffer是否包含指定值
    7. buf.includes(value[, byteOffset[, encoding]]) 判断Buffer是否包含指定值
    8. buf.keys() 遍历Buffer的每个字节
    9. buf.values() 遍历Buffer的每个字节
    10. buf.entries() 遍历Buffer的每个字节

    Buffer提供了丰富的方法用于创建、操作和转换二进制数据
    在Node.js中处理I/O操作、网络通信、文件读写等场景时非常有用
    熟练掌握这些方法可以更高效地处理二进制数据
`);







